const override = (target, source, ...sources) => {
  // target 目标对象，source 来源对象
  // 该方法用于覆盖目标的属性值，目标对象中存在的属性，来源对象中也存在的，则覆盖目标对象的属性值
  // 目标对象中不存在，来源对象中存在的，忽略
  // 目标对象中存在，来源对象中不存在的，忽略
  if (!target || typeof target !== 'object') {
    // 如果传进来的不是对象，则直接返回
    throw TypeError('目标对象类型错误，请传入对象类型')
    // return target
  }
  if (!source || typeof source !== 'object') {
    // 如果传入的来源对象为空或非对象类型，则赋值为空对象
    source = {}
  }
  if (target instanceof Array) {
    // 如果target类型是数组
  } else {
    for (const eachKey of Object.keys(target)) {
      const hasSourceKey = Object.prototype.hasOwnProperty.call(source, eachKey)
      if (hasSourceKey) {
        // 目标对象存在，来源对象也存在
        // 情景，如果目标对象属性为数组，则直接赋值
        // 情景，如果目标对象属性为对象，则执行override方法
        // 情景，如果目标对象属性为字符串、数字等类型，则直接赋值
        if (target[eachKey] === null || target[eachKey] === undefined) {
          target[eachKey] = source[eachKey]
        } else if (target[eachKey] instanceof Array) {
          target[eachKey] = source[eachKey]
        } else if (typeof target[eachKey] === 'object') {
          if (hasSourceKey && source[eachKey] instanceof Array) {
            target[eachKey] = source[eachKey]
          } else {
            override(target[eachKey], source[eachKey])
          }
        } else {
          target[eachKey] = source[eachKey]
        }
        /* else if (typeof target[eachKey] === 'string') {
          target[eachKey] = ''
        } else {
          target[eachKey] = undefined
        } */
      } // 目标对象存在，来源对象不存在的，忽略
    }
  }
  return target
}

const isEmpty = (data) => {
  if (data === null) return true
  if (data === undefined) return true
  if (typeof (data) === 'string') {
    return data === ''
  }
}

const camelToUnderlineCase = (str) => {
  if (!str) throw new Error('驼峰转下划线，源字符串不能为空')
  return str.replace(/([A-Z])/g, '_$1').toLowerCase()
}

export default {
  override,
  isEmpty,
  camelToUnderlineCase
}
